package com.ruoyix.aicode.util;


import com.ruoyix.aicode.domain.PageSection;
import com.ruoyix.aicode.domain.PageStyle;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Vue代码生成工具类
 */
public class VueGenerationUtil {
    private static final Logger logger = LoggerFactory.getLogger(VueGenerationUtil.class);

    /**
     * 从模板生成Vue骨架代码
     *
     * @param requirements 需求
     * @param pageSections 页面部分
     * @param pageStyle 页面风格
     * @param analysisContent 分析内容
     * @return 骨架代码
     */
    public static String generateVueSkeletonFromTemplate(String requirements, List<PageSection> pageSections,
                                                         PageStyle pageStyle, StringBuilder analysisContent) {
        logger.info("从模板生成Vue骨架代码，pageSections大小: {}", pageSections.size());

        // 构建Vue骨架
        StringBuilder skeletonBuilder = new StringBuilder();
        skeletonBuilder.append("<template>\n");
        skeletonBuilder.append("  <div class=\"vue-app-container\">\n");

        // 添加基础的Vue模板结构
        if (analysisContent != null && analysisContent.length() > 0) {
            // 从分析内容中提取HTML结构并转换为Vue结构
            String vueStructure = convertHtmlToVueTemplate(analysisContent.toString());
            skeletonBuilder.append(vueStructure);
        } else {
            // 默认Vue模板
            skeletonBuilder.append("    <!-- 页面内容将在这里生成 -->\n");
            skeletonBuilder.append("    <div class=\"container-fluid\">\n");
            skeletonBuilder.append("      <h1>{{ pageTitle }}</h1>\n");
            skeletonBuilder.append("      <div class=\"content-area\">\n");
            skeletonBuilder.append("        <!-- 组件将在这里生成 -->\n");
            skeletonBuilder.append("      </div>\n");
            skeletonBuilder.append("    </div>\n");
        }

        skeletonBuilder.append("  </div>\n");
        skeletonBuilder.append("</template>\n\n");

        // 添加脚本部分 - 使用Vue 3的script setup语法
        skeletonBuilder.append("<script setup>\n");
        skeletonBuilder.append("import { ref, reactive, computed, onMounted, onBeforeMount,onBeforeUpdate,onUpdated,onBeforeUnmount,onUnmounted,onErrorCaptured} from 'vue';\n");
        // 组件名称声明
        String name = extractName(requirements);
        skeletonBuilder.append("// 组件名: ").append(name).append("\n\n");

        // 页面标题 - 使用ref替代data
        skeletonBuilder.append("// 页面状态\n");
        skeletonBuilder.append("const pageTitle = ref('").append(extractTitle(requirements)).append("');\n");
        skeletonBuilder.append("// 更多响应式数据可以在这里定义\n");
        skeletonBuilder.append("const state = reactive({\n");
        skeletonBuilder.append("  loading: false,\n");
        skeletonBuilder.append("  // 更多状态数据\n");
        skeletonBuilder.append("});\n\n");

        // 计算属性
        skeletonBuilder.append("// 计算属性\n");
        skeletonBuilder.append("const computedValue = computed(() => {\n");
        skeletonBuilder.append("  return pageTitle.value;\n");
        skeletonBuilder.append("});\n\n");

        // 方法
        skeletonBuilder.append("// 方法定义\n");
        skeletonBuilder.append("const handleAction = () => {\n");
        skeletonBuilder.append("  console.log('执行操作');\n");
        skeletonBuilder.append("};\n\n");

        // 生命周期钩子 - 使用组合式API
        skeletonBuilder.append("// 生命周期钩子\n");
        skeletonBuilder.append("onMounted(() => {\n");
        skeletonBuilder.append("  console.log('组件已挂载');\n");
        skeletonBuilder.append("  // 初始化逻辑\n");
        skeletonBuilder.append("});\n");

        skeletonBuilder.append("</script>\n\n");

        // 添加样式部分
        skeletonBuilder.append("<style scoped>\n");

        // 使用默认字体
        String fontFamily = "'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif";
        skeletonBuilder.append(".vue-app-container {\n");
        skeletonBuilder.append("  font-family: ").append(fontFamily).append(";\n");

        // 根据颜色方案设置背景
        String colorScheme = "light"; // 默认值
        try {
            // 尝试获取颜色方案，如果无法获取则使用默认值
            colorScheme = pageStyle.toString().contains("colorScheme=dark") ? "dark" : "light";
        } catch (Exception e) {
            logger.warn("无法获取颜色方案，使用默认值: {}", e.getMessage());
        }

        if ("dark".equalsIgnoreCase(colorScheme)) {
            skeletonBuilder.append("  background-color: #343a40;\n");
            skeletonBuilder.append("  color: #f8f9fa;\n");
        } else {
            skeletonBuilder.append("  background-color: #f8f9fa;\n");
            skeletonBuilder.append("  color: #333;\n");
        }

        skeletonBuilder.append("  min-height: 100vh;\n");
        skeletonBuilder.append("  overflow: auto;\n");
//        skeletonBuilder.append("  padding: 20px;\n");
        skeletonBuilder.append("}\n\n");

        // 使用Element Plus作为默认UI框架
        skeletonBuilder.append("/* 使用Element Plus组件库的样式 */\n");
        skeletonBuilder.append(".el-button--primary {\n");
        skeletonBuilder.append("  background-color: #409eff;\n"); // Element Plus的主色调
        skeletonBuilder.append("  border-color: #409eff;\n");
        skeletonBuilder.append("}\n\n");

        skeletonBuilder.append("/* 自定义Element Plus样式 */\n");
        skeletonBuilder.append(".custom-element {\n");
        skeletonBuilder.append("  /* 自定义Element Plus样式可以在这里添加 */\n");
        skeletonBuilder.append("}\n\n");

        // 添加更多样式占位符
        if (!pageSections.isEmpty()) {
            skeletonBuilder.append("/* 组件样式占位符 */\n");
            appendCssPlaceholders(skeletonBuilder, pageSections, 0);
        }

        skeletonBuilder.append("</style>\n");

        return skeletonBuilder.toString();
    }

    /**
     * 从需求中提取标题
     */
    private static String extractTitle(String requirements) {
        // 简单提取标题，默认为"生成页面"
        String title = "生成页面";

        // 尝试从需求中提取更具体的标题
        if (requirements.toLowerCase().contains("视频") || requirements.toLowerCase().contains("影片")) {
            title = "视频网站首页";
        } else if (requirements.toLowerCase().contains("电商") || requirements.toLowerCase().contains("购物")) {
            title = "电商网站首页";
        } else if (requirements.toLowerCase().contains("博客") || requirements.toLowerCase().contains("文章")) {
            title = "博客网站首页";
        } else if (requirements.toLowerCase().contains("新闻")) {
            title = "新闻网站首页";
        }

        return title;
    }

    /**
     * 从需求中提取组件名称
     */
    private static String extractName(String requirements) {
        // 提取组件名称，默认为"GeneratedPage"
        String name = "GeneratedPage";

        if (requirements.toLowerCase().contains("视频") || requirements.toLowerCase().contains("影片")) {
            name = "VideoHome";
        } else if (requirements.toLowerCase().contains("电商") || requirements.toLowerCase().contains("购物")) {
            name = "ShoppingHome";
        } else if (requirements.toLowerCase().contains("博客") || requirements.toLowerCase().contains("文章")) {
            name = "BlogHome";
        } else if (requirements.toLowerCase().contains("新闻")) {
            name = "NewsHome";
        } else if (requirements.toLowerCase().contains("列表")) {
            name = "ListPage";
        } else if (requirements.toLowerCase().contains("表单")) {
            name = "FormPage";
        } else if (requirements.toLowerCase().contains("登录")) {
            name = "LoginPage";
        }

        return name;
    }

    /**
     * 添加CSS占位符
     */
    private static void appendCssPlaceholders(StringBuilder builder, List<PageSection> sections, int depth) {
        String indent = "  ".repeat(depth + 1);

        for (PageSection section : sections) {
            builder.append(indent).append("/* ").append(section.getId()).append(" */\n");

            // 添加一些基础样式
            builder.append(indent).append(".").append(toKebabCase(section.getId())).append(" {\n");
            builder.append(indent).append("  /* 样式将在组件生成时添加 */\n");
            builder.append(indent).append("}\n\n");

            // 递归添加子部分的CSS占位符
            if (!section.getChildren().isEmpty()) {
                appendCssPlaceholders(builder, section.getChildren(), depth + 1);
            }
        }
    }

    /**
     * 将单个组件集成到Vue骨架中
     *
     * @param sectionId 部分ID
     * @param componentContent 组件内容
     * @param skeletonCode 骨架代码
     * @return 更新后的骨架代码
     */
    public static String integrateComponentIntoVueSkeleton(String sectionId, String componentContent, StringBuilder skeletonCode) {
        logger.info("集成Vue组件 {} 到骨架中，组件内容长度: {}", sectionId, componentContent.length());
        String skeleton = skeletonCode.toString();

        try {
            // 提取组件的各个部分
            String templateContent = extractComponentPart(componentContent, "template");
            String scriptContent = extractComponentPart(componentContent, "script");
            String styleContent = extractComponentPart(componentContent, "style");

            logger.debug("提取的Vue组件部分 - template长度: {}, script长度: {}, style长度: {}",
                templateContent.length(), scriptContent.length(), styleContent.length());

            // 1. 处理template部分 - 支持两种占位符格式
            boolean templateInserted = false;

            // 格式1: <!-- SECTION: id --> 和 <!-- /SECTION: id -->
            String regexFormat1Start = "<!--\\s*SECTION:\\s*" + sectionId + "\\s*-->";
            String regexFormat1End = "<!--\\s*/SECTION:\\s*" + sectionId + "\\s*-->";

            Pattern startPattern1 = Pattern.compile(regexFormat1Start, Pattern.CASE_INSENSITIVE);
            Pattern endPattern1 = Pattern.compile(regexFormat1End, Pattern.CASE_INSENSITIVE);
            Matcher startMatcher1 = startPattern1.matcher(skeleton);
            Matcher endMatcher1 = endPattern1.matcher(skeleton);

            if (startMatcher1.find() && endMatcher1.find(startMatcher1.end())) {
                int startPos = startMatcher1.end();
                int endPos = endMatcher1.start();

                String before = skeleton.substring(0, startPos);
                String after = skeleton.substring(endPos);
                skeleton = before + "\n    " + templateContent + "\n    " + after;
                templateInserted = true;
                logger.info("使用标准SECTION标签成功插入组件 {} 的template内容", sectionId);
            }
            // 如果格式1未找到匹配，尝试简化格式
            else {
                // 格式2: <!-- id --> 和 <!-- /id --> 或 <!-- end id -->
                String regexFormat2Start = "<!--\\s*" + sectionId + "\\s*-->";
                String regexFormat2End = "<!--\\s*(?:/|end)\\s*" + sectionId + "\\s*-->";

                Pattern startPattern2 = Pattern.compile(regexFormat2Start, Pattern.CASE_INSENSITIVE);
                Pattern endPattern2 = Pattern.compile(regexFormat2End, Pattern.CASE_INSENSITIVE);
                Matcher startMatcher2 = startPattern2.matcher(skeleton);
                Matcher endMatcher2 = endPattern2.matcher(skeleton);

                if (startMatcher2.find() && endMatcher2.find(startMatcher2.end())) {
                    int startPos = startMatcher2.end();
                    int endPos = endMatcher2.start();

                    String before = skeleton.substring(0, startPos);
                    String after = skeleton.substring(endPos);
                    skeleton = before + "\n    " + templateContent + "\n    " + after;
                    templateInserted = true;
                    logger.info("使用简化SECTION标签成功插入组件 {} 的template内容", sectionId);
                }
            }

            // 如果仍未找到匹配，尝试使用占位符
            if (!templateInserted) {
                String componentPlaceholder = "<!-- " + sectionId + " -->";
                int placeholderPos = skeleton.indexOf(componentPlaceholder);
                if (placeholderPos != -1) {
                    skeleton = skeleton.replace(componentPlaceholder, templateContent);
                    templateInserted = true;
                    logger.info("使用占位符替换了组件 {} 的内容", sectionId);
                } else {
                    // 最后尝试在template结束前插入
                    int templateEndPos = skeleton.indexOf("</template>");
                    if (templateEndPos != -1) {
                        String beforeTemplate = skeleton.substring(0, templateEndPos);
                        String afterTemplate = skeleton.substring(templateEndPos);

                        // 添加带SECTION标记的组件
                        String insertContent = "\n    <!-- SECTION: " + sectionId + " -->\n    " +
                                              templateContent + "\n    " +
                                              "<!-- /SECTION: " + sectionId + " -->\n  ";

                        skeleton = beforeTemplate + insertContent + afterTemplate;
                        templateInserted = true;
                        logger.info("在template结束前插入了组件 {}", sectionId);
                    }
                }
            }

            // 2. 处理script部分
            if (scriptContent.length() > 0) {
                int scriptEndPos = skeleton.indexOf("</script>");
                if (scriptEndPos != -1) {
                    String scriptComment = "\n// " + sectionId + " 组件代码\n";
                    skeleton = skeleton.substring(0, scriptEndPos) +
                              scriptComment + scriptContent + "\n" +
                              skeleton.substring(scriptEndPos);
                    logger.info("已添加组件 {} 的脚本代码", sectionId);
                }
            }

            // 3. 处理style部分
            if (styleContent.length() > 0) {
                int styleEndPos = skeleton.indexOf("</style>");
                if (styleEndPos != -1) {
                    String styleComment = "\n/* " + sectionId + " 样式 */\n";
                    skeleton = skeleton.substring(0, styleEndPos) +
                              styleComment + styleContent + "\n" +
                              skeleton.substring(styleEndPos);
                    logger.info("已添加组件 {} 的样式代码", sectionId);
                }
            }

        } catch (Exception e) {
            logger.error("集成Vue组件时出错: {}", e.getMessage(), e);
        }

        return skeleton;
    }

    /**
     * 提取Vue组件部分
     */
    private static String extractComponentPart(String componentContent, String part) {
        String content = "";

        try {
            switch (part) {
                case "template":
                    // 使用更强大的方法提取template内容，处理嵌套的情况
                    content = extractBalancedContent(componentContent, "<template>", "</template>");
                    break;
                case "script":
                    // 处理script setup和普通script
                    if (componentContent.contains("<script setup>")) {
                        content = extractBalancedContent(componentContent, "<script setup>", "</script>");
                    } else {
                        content = extractBalancedContent(componentContent, "<script>", "</script>");
                    }
                    break;
                case "style":
                    // 处理不同的style标签（scoped, lang等）
                    // 先找到style开始标签的位置
                    int styleStart = -1;
                    Pattern stylePattern = Pattern.compile("<style[^>]*>");
                    Matcher styleMatcher = stylePattern.matcher(componentContent);
                    if (styleMatcher.find()) {
                        String styleOpeningTag = styleMatcher.group(0);
                        styleStart = styleMatcher.start();
                        // 然后从这个位置提取到匹配的</style>
                        String remainingContent = componentContent.substring(styleStart + styleOpeningTag.length());
                        int styleEndPos = findClosingTagPosition(remainingContent, "style");
                        if (styleEndPos >= 0) {
                            content = remainingContent.substring(0, styleEndPos).trim();
                        }
                    }
                    break;
            }
        } catch (Exception e) {
            logger.error("提取组件{}部分时出错: {}", part, e.getMessage(), e);
        }

        return content;
    }

    /**
     * 提取平衡的HTML内容（处理嵌套标签）
     *
     * @param content 完整内容
     * @param openTag 开始标签
     * @param closeTag 结束标签
     * @return 提取的内容（不包含开始和结束标签）
     */
    private static String extractBalancedContent(String content, String openTag, String closeTag) {
        int openPos = content.indexOf(openTag);
        if (openPos == -1) {
            return "";
        }

        int startPos = openPos + openTag.length();
        String remaining = content.substring(startPos);

        // 使用简单的标签计数器来处理嵌套情况
        String tagName = openTag.substring(1, openTag.indexOf(">"));
        int endPos = findClosingTagPosition(remaining, tagName);

        if (endPos >= 0) {
            return remaining.substring(0, endPos).trim();
        }

        // 如果找不到匹配的闭合标签，尝试使用简单的非贪婪匹配
        Pattern pattern = Pattern.compile(Pattern.quote(openTag) + "\\s*(.+?)\\s*" + Pattern.quote(closeTag), Pattern.DOTALL);
        Matcher matcher = pattern.matcher(content);
        if (matcher.find()) {
            return matcher.group(1);
        }

        return "";
    }

    /**
     * 查找闭合标签的位置（处理嵌套）
     *
     * @param content 内容
     * @param tagName 标签名（不包含<>）
     * @return 闭合标签在内容中的位置，如果找不到则返回-1
     */
    private static int findClosingTagPosition(String content, String tagName) {
        int depth = 1; // 初始深度为1（因为已经找到了开始标签）
        int pos = 0;

        // 不区分大小写的标签匹配
        String lowerTagName = tagName.toLowerCase();
        String upperTagName = tagName.toUpperCase();

        // 查找开始和结束标签的模式
        Pattern openPattern = Pattern.compile("<" + lowerTagName + "\\b|<" + upperTagName + "\\b", Pattern.CASE_INSENSITIVE);
        Pattern closePattern = Pattern.compile("</" + lowerTagName + "\\s*>|</" + upperTagName + "\\s*>", Pattern.CASE_INSENSITIVE);

        while (pos < content.length()) {
            // 查找下一个开始或结束标签
            Matcher openMatcher = openPattern.matcher(content);
            boolean foundOpen = openMatcher.find(pos);
            int openPos = foundOpen ? openMatcher.start() : Integer.MAX_VALUE;

            Matcher closeMatcher = closePattern.matcher(content);
            boolean foundClose = closeMatcher.find(pos);
            int closePos = foundClose ? closeMatcher.start() : Integer.MAX_VALUE;

            if (!foundOpen && !foundClose) {
                // 找不到更多标签
                break;
            }

            // 根据找到的标签类型增加或减少深度
            if (openPos < closePos) {
                // 找到新的开始标签
                depth++;
                pos = openPos + 1;
            } else {
                // 找到结束标签
                depth--;
                pos = closePos + 1;

                // 如果深度为0，说明找到了匹配的闭合标签
                if (depth == 0) {
                    return closePos;
                }
            }
        }

        // 如果找不到匹配的闭合标签
        return -1;
    }

    /**
     * 将HTML结构转换为Vue模板结构
     */
    private static String convertHtmlToVueTemplate(String html) {
        // 简单替换，实际应用中需要更复杂的处理
        String vueTemplate = html;

        // 替换class属性
        vueTemplate = vueTemplate.replaceAll("class=\"([^\"]*)\"", "class=\"$1\"");

        // 替换id为ref
        vueTemplate = vueTemplate.replaceAll("id=\"([^\"]*)\"", "ref=\"$1\"");

        // 将常见的HTML事件转换为Vue事件
        vueTemplate = vueTemplate.replaceAll("onclick=\"([^\"]*)\"", "@click=\"$1\"");
        vueTemplate = vueTemplate.replaceAll("onchange=\"([^\"]*)\"", "@change=\"$1\"");
        vueTemplate = vueTemplate.replaceAll("onsubmit=\"([^\"]*)\"", "@submit.prevent=\"$1\"");

        return vueTemplate;
    }

    /**
     * 将驼峰命名转换为kebab-case
     */
    private static String toKebabCase(String input) {
        return input.replaceAll("([a-z0-9])([A-Z])", "$1-$2").toLowerCase();
    }

    /**
     * 将ID转换为Vue组件名称
     */
    private static String toComponentName(String id) {
        // 将第一个字母和下划线后的第一个字母转为大写
        String[] parts = id.split("_");
        StringBuilder componentName = new StringBuilder();

        for (String part : parts) {
            if (part.length() > 0) {
                componentName.append(Character.toUpperCase(part.charAt(0)));
                if (part.length() > 1) {
                    componentName.append(part.substring(1));
                }
            }
        }

        return componentName.toString();
    }
}
